﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using ZedGraph;
//using System.Drawing;

//namespace Image_Test1
//{
//    class Histogram
//    {
//        public static double[] XaxisArr = new double[256];      //x-axis from 0 to 255

//        public static double[] RedArray = new double[256];      //hold the number of occurence of red pixels
//        public static double[] GreenArray = new double[256];     //hold the number of occurence of green pixels
//        public static double[] BlueArray = new double[256];      //hold the number of occurence of blue pixels
//        public static double[] grayArray = new double[256];      //hold the number of occurence of gray pixels

//        public static LineItem curve1;              //red curve
//        public static LineItem curve2;              //green curve
//        public static LineItem curve3;              //blue curve
//        public static LineItem curve4;              //gray curve
//        public static int redMax, GreenMax, BlueMax, GrayMax;
//        //creategraph
//        /// <summary>
//        /// draws the histogram graph of the image
//        /// </summary>
//        /// <param name="zgc">zed graph controller</param>
//        public static void CreateGraph(ZedGraphControl zgc)
//        {
           
//            // get a reference to the GraphPane
//            GraphPane myPane = zgc.GraphPane;

//            // Set the Titles
//            myPane.Title.Text = "Image Histogram";
//            myPane.XAxis.Title.Text = "Pixels value";
//            myPane.YAxis.Title.Text = "occurence of pixels";
//            myPane.Fill.Color = Color.CadetBlue;
//            // ImageTasks.DrawHistoGram(displayedimg);
//            //LineItem curve= myPane.AddCurve("red", ImageTasks.XaxisArr, ImageTasks.RedArray, Color.Red,SymbolType.Star);
//            //LineItem curve2 = myPane.AddCurve("green", ImageTasks.XaxisArr, ImageTasks.GreenArray, Color.Green, SymbolType.Diamond);
//            //LineItem curve3 = myPane.AddCurve("blue", ImageTasks.XaxisArr, ImageTasks.BlueArray, Color.Blue, SymbolType.Square);

//            //BarItem curf1=myPane.AddHiLowBar(

//            double xred, yred;
//            double xgreen, ygreen;
//            double xblue, yblue;
//            double xgray, ygray;
//            PointPairList list1 = new PointPairList();
//            PointPairList list2 = new PointPairList();
//            PointPairList list3 = new PointPairList();
//            PointPairList list4 = new PointPairList();
//            for (int i = 0; i < 255; i++)
//            {
//                xred = xgreen = xblue = xgray = (double)i + 1;
//                yred = Histogram.RedArray[i];
//                ygreen = Histogram.GreenArray[i];
//                yblue = Histogram.BlueArray[i];
//                ygray = Histogram.grayArray[i];
//                list1.Add(xred, yred);
//                list2.Add(xgreen, ygreen);
//                list3.Add(xblue, yblue);
//                list4.Add(xgray, ygray);
//                int penTransparency = 100;
//                Color red = Color.FromArgb(penTransparency, 255, 10, 10);
//                Color green = Color.FromArgb(penTransparency, 0, 255, 0);
//                Color blue = Color.FromArgb(penTransparency, 0, 0, 255);
//                curve1 = myPane.AddStick("", list1, red);
//                curve2 = myPane.AddStick("", list2, green);
//                curve3 = myPane.AddStick("", list3, blue);
//                curve4 = myPane.AddStick("", list4, Color.Gray);
//            }
//            zgc.AxisChange();
//        }
        
//        //histogram
//        /// <summary>
//        /// calculate the histogram values  
//        /// </summary>
//        /// <param name="img">array of pixels of the image to draw its histogram</param>
//        public static void DrawHistoGram(ColorStruct.col[,] img)
//        {
//            int height = ImageTasks.GetHeight(img);
//            int width = ImageTasks.GetWidth(img);

//            redMax = 0;
//            GreenMax = 0;
//            BlueMax = 0;
//            GrayMax = 0;
//            for (int i = 0; i < 255; i++)
//            {
//                XaxisArr[i] = i;
//            }

//            for (int i = 0; i < 256; i++)
//            {
//                RedArray[i] = 0;
//                GreenArray[i] = 0;
//                BlueArray[i] = 0;
//                grayArray[i] = 0;
//            }
//            for (int i = 0; i < height; i++)
//            {
//                for (int j = 0; j < width; j++)
//                {
//                    int red = img[i, j].R;
//                    RedArray[red]++;
//                    if (red > redMax)
//                        redMax = red;

//                    int green = img[i, j].G;
//                    GreenArray[green]++;
//                    if (green > GreenMax)
//                        GreenMax = green;

//                    int blue = img[i, j].B;
//                    BlueArray[blue]++;
//                    if (blue > BlueMax)
//                        BlueMax = blue;

//                    int gray = (img[i, j].R + img[i, j].G + img[i, j].B) / 3;
//                    grayArray[gray]++;
//                    if (gray > GrayMax)
//                        GrayMax = gray;

//                }
//            }
//            for (int i = 0; i < 255; i++)
//            {
//                RedArray[i] = (RedArray[i] / redMax) * 210;
//                GreenArray[i] = (GreenArray[i] / GreenMax) * 210;
//                BlueArray[i] = (BlueArray[i] / BlueMax) * 210;
//                grayArray[i] = (grayArray[i] / GrayMax) * 210;
//            }
//        }


//        public static ColorStruct.col[] equalization(ColorStruct.col[,] img)
//        {
//            DrawHistoGram(img);
//            int height = ImageTasks.GetHeight(img);
//            int width = ImageTasks.GetWidth(img);
//            double[] sumRed = new double[256];
//            double[] sumGreen = new double[256];
//            double[] sumBlue = new double[256];

//            double[] sumRedRun = new double[256];
//            double[] sumGreenRun = new double[256];
//            double[] sumBlueRun = new double[256];

//            ColorStruct.col[] round = new ColorStruct.col[256];
//            ColorStruct.col x;
//            for (int i = 0; i < height; i++)
//                for (int j = 0; j < width; j++)
//                {
//                    x.R = img[i, j].R;
//                    x.G = img[i, j].G;
//                    x.B = img[i, j].B;
//                    sumRed[x.R] = sumRed[x.R] + 1;
//                    sumGreen[x.R] = sumGreen[x.R] + 1;
//                    sumBlue[x.R] = sumBlue[x.R] + 1;

//                }
//            sumRedRun[0] = RedArray[0];
//            sumGreenRun[0] = GreenArray[0];
//            sumBlueRun[0] = BlueArray[0];

//            for (int i = 1; i < 256; i++)
//            {
//                sumRedRun[i] = sumRedRun[i - 1] + RedArray[i];
//                sumGreenRun[i] = sumGreenRun[i - 1] + GreenArray[i];
//                sumBlueRun[i] = sumBlueRun[i - 1] + BlueArray[i];

//            }
           
//            int rMax = redMax;
//            int gMax = GreenMax;
//            int bMax = BlueMax;
//            for (int i = 0; i < 256; i++)
//            {
//                sumRedRun[i] /= (width*height);
//                sumRedRun[i] *= redMax;
//                round[i].R = (int)Math.Round((double)sumRedRun[i]);

//                sumGreenRun[i] /= (width * height);
//                sumGreenRun[i] *= GreenMax;
//                round[i].G = (int)Math.Round((double)sumGreenRun[i]);

//                sumBlueRun[i] /= (width * height);
//                sumBlueRun[i] *= BlueMax;
//                round[i].B = (int)Math.Round((double)sumBlueRun[i]);

//            }
//            return round;
//        }


//        public static ColorStruct.col[,] equalizationEffect(ColorStruct.col[,] img)
//        {
//            ColorStruct.col[] round = equalization(img);
//            int height = ImageTasks.GetHeight(img);
//            ColorStruct.col pixel;
//            int width = ImageTasks.GetWidth(img);
//            ColorStruct.col[,] Imgcopy = new ColorStruct.col[height, width];
//            for (int i = 0; i < height; i++)
//            {
//                for (int j = 0; j < width; j++)
//                {
//                    int r = img[i, j].R;
//                    pixel.R = round[r].R;

//                    int g = img[i, j].G;
//                    pixel.G = round[g].G;

//                    int b = img[i, j].B;
//                    pixel.B = round[b].B;

//                    Imgcopy[i, j] = pixel;
//                }
//            }
//            return Imgcopy;
//        }

//        //public static ColorStruct.col[,] Equalization(ColorStruct.col[,] Buffer)
//        //{
//        //    DrawHistoGram(Buffer);
//        //    int Width = Buffer.GetLength(0);
//        //    int Height = Buffer.GetLength(1);
//        //    ColorStruct.col [,]ChangedBufferValue;
//        //    ChangedBufferValue = new ColorStruct.col[Width, Height];
//        //    double[] RunningSumRed = new double[256];
//        //    double[] RunningSumBlue = new double[256];
//        //    double[] RunningSumGreen = new double[256];
//        //    RunningSumRed[0] = RedArray[0];
//        //    RunningSumBlue[0] = BlueArray[0];
//        //    RunningSumGreen[0] = GreenArray[0];
//        //    for (int i = 1; i < 256; i++)
//        //    {
//        //        RunningSumRed[i] = RunningSumRed[i - 1] + RedArray[i];
//        //        RunningSumBlue[i] = RunningSumBlue[i - 1] + BlueArray[i];
//        //        RunningSumGreen[i] = RunningSumGreen[i - 1] + GreenArray[i];
//        //        RunningSumRed[i - 1] /= (Width * Height);
//        //        RunningSumRed[i - 1] *= redMax;
//        //        RunningSumBlue[i - 1] /= (Width * Height);
//        //        RunningSumBlue[i - 1] *= GreenMax;
//        //        RunningSumGreen[i - 1] /= (Width * Height);
//        //        RunningSumGreen[i - 1] *= BlueMax;

//        //    }
//        //    RunningSumRed[255] /= (Width * Height);
//        //    RunningSumRed[255] *= 255;
//        //    RunningSumGreen[255] /= (Width * Height);
//        //    RunningSumGreen[255] *= 255;
//        //    RunningSumBlue[255] /= (Width * Height);
//        //    RunningSumBlue[255] *= 255;
//        //    for (int W = 0; W < Width; W++)
//        //        for (int H = 0; H < Height; H++)
//        //        {
//        //            ChangedBufferValue[W,H].R = (byte)Math.Round(RunningSumRed[(int)Buffer[W, H].R]);
//        //            ChangedBufferValue[W,H].G = (byte)Math.Round(RunningSumGreen[(int)Buffer[W, H].G]);
//        //            ChangedBufferValue[W,H].B = (byte)Math.Round(RunningSumBlue[(int)Buffer[W, H].B]);
//        //            //ChangedBuffer[W, H] = Color.FromArgb((int)ChangedBufferValue.R, (int)ChangedBufferValue.G, (int)ChangedBufferValue.B);
//        //        }
//        //    return ChangedBufferValue;
//        //}

//          public static ColorStruct.col[,] MatchingHistobram(ColorStruct.col[,] img1,ColorStruct.col[,] img2)
//        {
//            int height = ImageTasks.GetHeight(img1);
//            int width = ImageTasks.GetWidth(img1);
//            ColorStruct.col[,] NewImage=new ColorStruct.col[height,width];
//            ColorStruct.col[] round1;
//            ColorStruct.col[] round2;
//            ColorStruct.col[] round3=new  ColorStruct.col[256];
//            ColorStruct.col[] color=new  ColorStruct.col[256];
//            round1 = equalization(img1);
//            round2 = equalization(img2);
//            ColorStruct.col min;
//            int x = 0; 
//            for(int i=0;i<256;i++)
//            {
//                color[i].R=i;
//                color[i].G=i;
//                color[i].B=i;
//            }
//            for (int i = 0; i < 256; i++)//eq1
//            {
//                min.R = 1000;
//                min.G = 1000;
//                min.B = 1000;
//                for (int j = 0; j < 256; j++)//eq2
//                {
//                    int RedDiff = Math.Abs (round1[i].R - round2[j].R);
//                    int GreenDiff = Math.Abs(round1[i].G - round2[j].G);
//                    int BlueDiff = Math.Abs(round1[i].B - round2[j].B);
//                    //int totalColor = RedDiff + GreenDiff + BlueDiff;
//                    //if (totalColor < min.B + min.G + min.B)
//                    //{
//                    //    min.R = RedDiff;
//                    //    min.G = GreenDiff;
//                    //    min.B = BlueDiff;
//                    //    x = j;
//                    //    round3[i].R = color[x].R;
//                    //    round3[i].G = color[x].G;
//                    //    round3[i].B = color[x].B;
//                    //}
//                    if (RedDiff < min.R)
//                    {
//                        min.R = RedDiff;
//                        x = j;
//                        round3[i].R = color[x].R;
//                    }
//                    if (GreenDiff < min.G)
//                    {
//                        min.G = GreenDiff;
//                        x = j;
//                        round3[i].G = color[x].G;
//                    }
//                    if (BlueDiff < min.B)
//                    {
//                        min.B = BlueDiff;
//                        x = j;
//                        round3[i].B = color[x].B;
//                    }
//                }
//               // if (min.R < Math.Abs(max.R))
//                //{
//                    //round3[i] = color[x];
//                //}
//                //else
//                  //  round3[i] = color[y];
//            }
//            int r, b, g;
//            for(int i=0;i<height;i++)
//                for (int j = 0; j < width; j++)
//                {
//                    r = img1[i, j].R;
//                    NewImage[i, j].R = round3[r].R;
//                    g = img1[i, j].G;
//                    NewImage[i, j].G = round3[g].G;
//                    b = img1[i, j].B;
//                    NewImage[i, j].B = round3[b].B;

//                }
//            return NewImage;

//        }

//    }
//}
